import accountType from "./webim_wx.js";
var webim = accountType.webim;

//最近联系人
var reqRecentSessCount = 200; //每次请求的最近会话条数，业务可以自定义
var maxNameLen = 12; //我的好友或群组列表中名称显示最大长度，仅demo用得到
var recentSessMap = {}; //保存最近会话列表
var totalCount = 200; //每次接口请求的条数，bootstrap table 分页时用到
//聊天
var selType = webim.SESSION_TYPE.C2C; //当前聊天类型C2C单聊
var friendHeadUrl = require("../../img/im/avter.png"); //用于没有设置过头像的好友
var groupHeadUrl = require("../../img/im/avter.png"); //用于没有设置过头像的好友
var uptime = ""; //上次发消息时间，原来判断是否显示时间
var reqMsgCount = 15; //每次请求的历史消息(c2c获取群)条数，仅demo用得到
var selToID = null; //聊天对象
var selSess = null;
var emotionFlag = false; //是否显示表情框
var loginInfo = {
  sdkAppID: "1400786819", //用户所属应用id,必填
  identifier: "", //当前用户ID,必须是否字符串类型，必填
  accountType: 36862, //用户所属应用帐号类型，必填
  userSig: "",
  //当前用户身份凭证，必须是字符串类型，必填
  identifierNick: "", //当前用户昵称，不用填写，登录接口会返回用户的昵称，如果没有设置，则返回用户的id
  headurl: require("../../img/im/laoshi.png") //当前用户默认头像，选填，如果设置过头像，则可以通过拉取个人资料接口来得到头像信息
};
var getPrePageC2CHistroyMsgInfoMap = {}; //保留下一次拉取好友历史消息的信息
var getPrePageGroupHistroyMsgInfoMap = {}; //保留下一次拉取群历史消息的信息
var infoMap = {};
//监听事件
var listeners = {
  jsonpCallback: jsonpCallback, //IE9(含)以下浏览器用到的jsonp回调函数，
  onMsgNotify: onMsgNotify, //监听新消息(私聊，普通群(非直播聊天室)消息，全员推送消息)事件，必填
  onC2cEventNotifys: onMsgReadedNotify //监听 C2C 系统消息通道
};
//初始化时，其他对象，选填
var options = {
  isAccessFormalEnv: true, //是否访问正式环境，默认访问正式，选填
  isLogOn: false //是否开启控制台打印日志,默认开启，选填
};
var self;

//登录
function webimLogin(selfs, cbOK) {
  self = selfs;
  selToID = self.selToID;
  loginInfo.identifier = self.identifier;
  loginInfo.userSig = self.imSigns;
  webim.login(
    loginInfo,
    listeners,
    options,
    function(resp) {
      if (cbOK) {
        cbOK();
      }
    },
    function(err) {
      alert(err.ErrorInfo);
    }
  );
}

//消息已读通知
function onMsgReadedNotify(notify) {
  console.log(notify);
  var sessMap = webim.MsgStore.sessMap()[
    webim.SESSION_TYPE.C2C + notify.From_Account
  ];
  if (sessMap) {
    var msgs = _.clone(sessMap.msgs());
    var rm_msgs = _.remove(msgs, function(m) {
      return m.time <= notify.LastReadTime;
    });
    var unread = sessMap.unread() - rm_msgs.length;
    unread = unread > 0 ? unread : 0;
    //更新sess的未读数
    sessMap.unread(unread);
    // console.debug('更新C2C未读数:',notify.From_Account,unread);
    //更新页面的未读数角标

    if (unread > 0) {
      $("#badgeDiv_" + notify.From_Account)
        .text(unread)
        .show();
    } else {
      $("#badgeDiv_" + notify.From_Account)
        .val("")
        .hide();
    }
  }
}

//将我的好友资料（昵称和头像）保存在infoMap
function setProfilePortraitClick(To_Account, cbOK) {
  selToID = self.selToID;
  if (!To_Account) {
    To_Account = [self.selToID];
  }
  var tag_list = [
    "Tag_Profile_IM_Nick", //昵称
    "Tag_Profile_IM_Gender", //性别
    "Tag_Profile_IM_Location", //所在地
    "Tag_Profile_IM_Image", //头像
    "Tag_Profile_IM_Role" //等级
  ];
  var options = {
    To_Account: To_Account,
    TagList: tag_list
  };
  webim.getProfilePortrait(
    options,
    function(resp) {
      if (resp.UserProfileItem && resp.UserProfileItem.length > 0) {
        for (var i in resp.UserProfileItem) {
          var nick, gender, allowType, image, role;
          if (resp.UserProfileItem[i].ProfileItem) {
            for (var j in resp.UserProfileItem[i].ProfileItem) {
              switch (resp.UserProfileItem[i].ProfileItem[j].Tag) {
                case "Tag_Profile_IM_Nick":
                  nick = resp.UserProfileItem[i].ProfileItem[j].Value;
                  break;
                case "Tag_Profile_IM_Gender":
                  gender = resp.UserProfileItem[i].ProfileItem[j].Value;
                  break;
                case "Tag_Profile_IM_Location":
                  allowType = resp.UserProfileItem[i].ProfileItem[j].Value;
                  break;
                case "Tag_Profile_IM_Image":
                  image = resp.UserProfileItem[i].ProfileItem[j].Value;
                  break;
                case "Tag_Profile_IM_Role":
                  role = resp.UserProfileItem[i].ProfileItem[j].Value;
                  break;
              }
              var key =
                webim.SESSION_TYPE.C2C + "_" + resp.UserProfileItem[i].To_Account;
                infoMap[key] = {
                name: nick,
                image: image,
                gender: gender
              };
            }
          }else{
            // eslint-disable-next-line no-redeclare
            var key =
              webim.SESSION_TYPE.C2C + "_" + resp.UserProfileItem[i].To_Account;
            infoMap[key] = {
              name: resp.UserProfileItem[i].To_Account,
              image: friendHeadUrl,
              gender: gender
            };
          }
        }
        //console.log(infoMap)
        if (cbOK) {
          cbOK();
        }
      } 
    },
    function(err) {
      alert(err.ErrorInfo);
    }
  );
}

function infoname() {
  var key = webim.SESSION_TYPE.C2C + "_" + selToID;
  var info = infoMap[key];
  if (info && info.name) {
    self.infoname_text = info.name;
  } else {
    self.infoname_text = "";
  }
}

//发送消息
function onSendMsg(msgedit) {
  if (!selToID) {
    error("你还没有选中好友或者群组，暂不能聊天!");
    return;
  }
  //获取消息内容
  var msgContent = msgedit;
  var msgLen = webim.Tool.getStrBytes(msgContent);

  if (msgContent.length < 1) {
    error("发送的消息不能为空!");
    return;
  }
  var maxLen, errInfo;
  if (selType == webim.SESSION_TYPE.C2C) {
    maxLen = webim.MSG_MAX_LENGTH.C2C;
    errInfo = "消息长度超出限制(最多" + Math.round(maxLen / 3) + "汉字)";
  } else {
    maxLen = webim.MSG_MAX_LENGTH.GROUP;
    errInfo = "消息长度超出限制(最多" + Math.round(maxLen / 3) + "汉字)";
  }
  if (msgLen > maxLen) {
    error(errInfo);
    return;
  }
  //发消息处理
  handleMsgSend(selToID, msgContent);

  bdscrollbar(100); //滚动条
}

//监听接收消息
var msgList = [];
var dateStart = null;
var dateEnd = null;
function onMsgNotify(newMsgList) {
  //console.log(newMsgList);
  //return
  var sess, newMsg, msgtext;
  //获取所有聊天会话
  var sessMap = webim.MsgStore.sessMap();

  for (var j in newMsgList) {
    //遍历新消息
    newMsg = newMsgList[j];
    
      //没有聊天对象
      selToID = newMsg.getSession().id();
      selType = newMsg.getSession().type();
      selSess = newMsg.getSession();

      sess = newMsg.getSession();
      if (sess.msgs()[sess.msgs().length - 1].elems[0].type == "TIMCustomElem") {
        msgtext = "[图片]";
      } else if (
        sess.msgs()[sess.msgs().length - 1].elems[0].type == "TIMFaceElem"
      ) {
        msgtext = "[表情]";
      } else {
        msgtext = sess.msgs()[sess.msgs().length - 1].elems[0].content.text;
      }

      var headUrl;
      if (selType == webim.SESSION_TYPE.C2C) {
          headUrl = friendHeadUrl;
      } else {
          headUrl = groupHeadUrl;
      }
      addSess(
        selType,
        selToID,
        newMsg.getSession().name(),
        headUrl,
        newMsg.getSession().unread(),
        "sesslist",
        "",
        newMsg.getSession().time(),
        msgtext
      ); //新增一个对象
      //setSelSessStyleOn(selToID);
    if (newMsg.getSession().id() == selToID) {
      //为当前聊天对象的消息
      //在聊天窗体中新增一条消息
      //console.warn(newMsg);

      addMsg(newMsg, true);
      bdscrollbar(100); //滚动条
    }
    msgList.push(newMsg.elems[0].content.text);
  }
  //消息已读上报，以及设置会话自动已读标记
  // webim.setAutoRead(selSess, true, true);

  /* for (var i in sessMap) {
    sess = sessMap[i];
    if (sess.msgs()[sess.msgs().length - 1].elems[0].type == "TIMCustomElem") {
      msgtext = "[图片]";
    } else if (
      sess.msgs()[sess.msgs().length - 1].elems[0].type == "TIMFaceElem"
    ) {
      msgtext = "[表情]";
    } else {
      msgtext = sess.msgs()[sess.msgs().length - 1].elems[0].content.text;
    }
    //更新其他聊天对象的未读消息数
    updateSessDiv(
      sess.type(),
      sess.id(),
      sess.name(),
      sess.unread(),
      sess.time(),
      msgtext
    );
    //console.debug(sess.id(), sess.unread());
    //dateEnd = new Date();
  } */
}

//获取好友历史消息
var getLastC2CHistoryMsgs = function(cbOk, cbError) {
  if (selType == webim.SESSION_TYPE.GROUP) {
    alert("当前的聊天类型为群聊天，不能进行拉取好友历史消息操作");
    return;
  }

  if (!selToID || selToID == "@TIM#SYSTEM") {
    //alert('当前的聊天id非法，selToID=' + selToID);
    return;
  }

  var lastMsgTime = 0; //第一次拉取好友历史消息时，必须传0
  var msgKey = "";
  var options = {
    Peer_Account: selToID, //好友帐号
    MaxCnt: reqMsgCount, //拉取消息条数
    LastMsgTime: lastMsgTime, //最近的消息时间，即从这个时间点向前拉取历史消息
    MsgKey: msgKey
  };
  selSess = null;

  webim.MsgStore.delSessByTypeId(selType, selToID);

  webim.getC2CHistoryMsgs(
    options,
    function(resp) {
      var complete = resp.Complete; //是否还有历史消息可以拉取，1-表示没有，0-表示有

      if (resp.MsgList.length == 0) {
        //webim.Log.warn("没有历史消息了:data=" + JSON.stringify(options));
        return;
      }
      getPrePageC2CHistroyMsgInfoMap[selToID] = {
        //保留服务器返回的最近消息时间和消息Key,用于下次向前拉取历史消息
        LastMsgTime: resp.LastMsgTime,
        MsgKey: resp.MsgKey
      };
      //清空聊天界面

      if (cbOk) cbOk(resp.MsgList);
    },
    cbError
  );
};

//向上翻页，获取更早的好友历史消息
var getPrePageC2CHistoryMsgs = function(cbOk, cbError) {
  if (selType == webim.SESSION_TYPE.GROUP) {
    alert("当前的聊天类型为群聊天，不能进行拉取好友历史消息操作");
    return;
  }
  var tempInfo = getPrePageC2CHistroyMsgInfoMap[selToID]; //获取下一次拉取的c2c消息时间和消息Key
  var lastMsgTime;
  var msgKey;
  if (tempInfo) {
    lastMsgTime = tempInfo.LastMsgTime;
    msgKey = tempInfo.MsgKey;
  } else {
    //alert("获取下一次拉取的c2c消息时间和消息Key为空");
    return;
  }

  var options = {
    Peer_Account: selToID, //好友帐号
    MaxCnt: reqMsgCount, //拉取消息条数
    LastMsgTime: lastMsgTime, //最近的消息时间，即从这个时间点向前拉取历史消息
    MsgKey: msgKey
  };
  webim.getC2CHistoryMsgs(
    options,
    function(resp) {
      var complete = resp.Complete; //是否还有历史消息可以拉取，1-表示没有，0-表示有
      if (resp.MsgList.length == 0) {
        error("没有历史消息了");
        if (cbError) {
          cbError("");
        }
      }
      getPrePageC2CHistroyMsgInfoMap[selToID] = {
        //保留服务器返回的最近消息时间和消息Key,用于下次向前拉取历史消息
        LastMsgTime: resp.LastMsgTime,
        MsgKey: resp.MsgKey
      };
      if (cbOk) {
        cbOk(resp.MsgList);
      } else {
        getHistoryMsgCallback(resp.MsgList, true);
      }
    },
    cbError
  );
};

//显示历史消息
function getHistoryMsgCallback(msgList, prepage) {
  var msg;
  prepage = prepage || false;
  //如果是加载前几页的消息，消息体需要prepend，所以先倒排一下

  if (!prepage) {
    msgList.reverse();
  }
  for (var j in msgList) {
    //遍历新消息
    msg = msgList[j];
    if (msg.getSession().id() == selToID) {
      //为当前聊天对象的消息
      selSess = msg.getSession();
      //在聊天窗体中新增一条消息
      addMsg(msg, prepage);
    }
  }
  //消息已读上报，并将当前会话的消息设置成自动已读
  webim.setAutoRead(selSess, true, true);
}

//处理消息开始
function handleMsgSend(selToID, msgContent) {
  if (!selSess) {
    var selSess = new webim.Session(
      selType,
      selToID,
      selToID,
      friendHeadUrl,
      Math.round(new Date().getTime() / 1000)
    );
  }
  var isSend = true; //是否为自己发送
  var seq = -1; //消息序列，-1表示sdk自动生成，用于去重
  var random = Math.round(Math.random() * 4294967296); //消息随机数，用于去重
  var msgTime = Math.round(new Date().getTime() / 1000); //消息时间戳
  var subType; //消息子类型
  if (selType == webim.SESSION_TYPE.C2C) {
    subType = webim.C2C_MSG_SUB_TYPE.COMMON;
  } else {
    //webim.GROUP_MSG_SUB_TYPE.COMMON-普通消息,
    //webim.GROUP_MSG_SUB_TYPE.LOVEMSG-点赞消息，优先级最低
    //webim.GROUP_MSG_SUB_TYPE.TIP-提示消息(不支持发送，用于区分群消息子类型)，
    //webim.GROUP_MSG_SUB_TYPE.REDPACKET-红包消息，优先级最高
    subType = webim.GROUP_MSG_SUB_TYPE.COMMON;
  }
  var msg = new webim.Msg(
    selSess,
    isSend,
    seq,
    random,
    msgTime,
    loginInfo.identifier,
    subType,
    loginInfo.identifierNick
  );

  var text_obj, face_obj, tmsg, emotionIndex, emotion, restMsgIndex;
  //解析文本和表情
  var expr = /\[[^[\]]{1,3}\]/gm;
  var emotions = msgContent.match(expr);
  if (!emotions || emotions.length < 1) {
    text_obj = new webim.Msg.Elem.Text(msgContent);
    msg.addText(text_obj);
  } else {
    for (var i = 0; i < emotions.length; i++) {
      tmsg = msgContent.substring(0, msgContent.indexOf(emotions[i]));
      if (tmsg) {
        text_obj = new webim.Msg.Elem.Text(tmsg);
        msg.addText(text_obj);
      }
      emotionIndex = webim.EmotionDataIndexs[emotions[i]];
      emotion = webim.Emotions[emotionIndex];

      if (emotion) {
        face_obj = new webim.Msg.Elem.Face(emotionIndex, emotions[i]);
        msg.addFace(face_obj);
      } else {
        text_obj = new webim.Msg.Elem.Text(emotions[i]);
        msg.addText(text_obj);
      }
      restMsgIndex = msgContent.indexOf(emotions[i]) + emotions[i].length;
      msgContent = msgContent.substring(restMsgIndex);
    }
    if (msgContent) {
      text_obj = new webim.Msg.Elem.Text(msgContent);
      msg.addText(text_obj);
    }
  }
  msg.PushInfoBoolean = true; //是否开启离线推送push同步
  msg.sending = 1;
  msg.originContent = msgContent;
  addMsg(msg, true);

  self.msgedit = "";
  //document.querySelector("#msg input").value=''
  //console.log(document.querySelector("#msg input").value)
  //$("#send_msg_text").val('');
  //turnoffFaces_box();

  webim.sendMsg(
    msg,
    function(resp) {
      //console.debug(msg);
      //发送成功，把sending清理
      //$("#id_" + msg.random).find(".spinner").remove();
      //webim.Tool.setCookie("tmpmsg_" + selToID, '', 0);
    },
    function(err) {
      //console.debug(err);
      alert(err.ErrorInfo);
      //提示重发
      //showReSend(msg);
    }
  );
}

//显示消息
function addMsg(msg, prepend) {
  var isSelfSend,
    fromAccount,
    fromAccountNick,
    fromAccountImage,
    sessType,
    subType,
    classname,
    msg,
    time,
    img,
    scrollTop;

  //获取会话类型，目前只支持群聊
  //webim.SESSION_TYPE.GROUP-群聊，
  //webim.SESSION_TYPE.C2C-私聊，
  sessType = msg.getSession().type();

  isSelfSend = msg.getIsSend(); //消息是否为自己发的

  fromAccount = msg.getFromAccount();
  if (!fromAccount) {
    return;
  }
  if (isSelfSend) {
    //如果是自己发的消息
    if (loginInfo.identifierNick) {
      fromAccountNick = loginInfo.identifierNick;
    } else {
      fromAccountNick = fromAccount;
    }
    //获取头像
    if (loginInfo.headurl) {
      fromAccountImage = self.$fnc.getImgUrl(loginInfo.headurl);
    } else {
      fromAccountImage = friendHeadUrl;
    }
    classname = true;
  } else {
    //如果别人发的消息
    var key = webim.SESSION_TYPE.C2C + "_" + fromAccount;
    var info = infoMap[key];
    if (info && info.name) {
      fromAccountNick = info.name;
    } else if (msg.getFromAccountNick()) {
      fromAccountNick = msg.getFromAccountNick();
    } else {
      fromAccountNick = fromAccount;
    }
    //获取头像
    if (info && info.image) {
      fromAccountImage = self.$fnc.getImgUrl(info.image);
    } else if (msg.fromAccountHeadurl) {
      fromAccountImage = msg.fromAccountHeadurl;
    } else {
      fromAccountImage = friendHeadUrl;
    }
    classname = false;
  }
  time = webim.Tool.formatTimeStamp(msg.getTime());

  if (uptime == "") {
    uptime = time;
  } else {
    if ((new Date(time).getTime() - new Date(uptime).getTime()) / 1000 > 60) {
      uptime = time;
    } else {
      uptime = time;
      time = "";
    }
  }
  //获取消息子类型
  //会话类型为群聊时，子类型为：webim.GROUP_MSG_SUB_TYPE
  //会话类型为私聊时，子类型为：webim.C2C_MSG_SUB_TYPE
  subType = msg.getSubType();
  switch (subType) {
    case webim.GROUP_MSG_SUB_TYPE.COMMON: //群普通消息
      msg = convertMsgtoHtml(msg);
      break;
    case webim.GROUP_MSG_SUB_TYPE.REDPACKET: //群红包消息
      msg = "[群红包消息]" + convertMsgtoHtml(msg);
      break;
    case webim.GROUP_MSG_SUB_TYPE.LOVEMSG: //群点赞消息
      //业务自己可以增加逻辑，比如展示点赞动画效果
      msg = "[群点赞消息]" + convertMsgtoHtml(msg);
      //展示点赞动画
      //showLoveMsgAnimation();
      break;
    case webim.GROUP_MSG_SUB_TYPE.TIP: //群提示消息
      msg = "[群提示消息]" + convertMsgtoHtml(msg);
      break;
  }
  if (prepend) {
    self.textvalue.push({
      msg: msg,
      avter: fromAccountImage,
      time: time,
      classname: classname
    });
  } else {
    self.textvalue.unshift({
      msg: msg,
      avter: fromAccountImage,
      time: time,
      classname: classname
    });
  }
}

//转消息内容
function convertMsgtoHtml(msg) {
  var html = "",
    elems,
    elem,
    type,
    content,
    types = 0;
  elems = msg.getElems(); //获取消息包含的元素数组
  var count = elems.length;
  for (var i = 0; i < count; i++) {
    elem = elems[i];
    type = elem.getType(); //获取元素类型
    content = elem.getContent(); //获取元素对象

    switch (type) {
      case webim.MSG_ELEMENT_TYPE.TEXT:
        //文字
        var eleHtml = convertTextMsgToHtml(content);
        //转义，防XSS
        html += webim.Tool.formatText2Html(eleHtml);
        break;
      case webim.MSG_ELEMENT_TYPE.FACE:
        //表情
        html = convertFaceMsgToHtml(content);
        types = 1;
        return { html, types };
      case webim.MSG_ELEMENT_TYPE.IMAGE:
        //图片
        //html = convertImageMsgToHtml(content);
        //types=1;
        //return {html,types};
        break;
      case webim.MSG_ELEMENT_TYPE.SOUND:
        html += convertSoundMsgToHtml(content);
        break;
      case webim.MSG_ELEMENT_TYPE.FILE:
        html += convertFileMsgToHtml(content);
        break;
      case webim.MSG_ELEMENT_TYPE.LOCATION:
        html += convertLocationMsgToHtml(content);
        break;
      case webim.MSG_ELEMENT_TYPE.CUSTOM:
        var eleHtml = convertCustomMsgToHtml(content);
        //转义，防XSS
        html = webim.Tool.formatText2Html(eleHtml);
        types = 1;
        return { html, types };
      case webim.MSG_ELEMENT_TYPE.GROUP_TIP:
        var eleHtml = convertGroupTipMsgToHtml(content);
        //转义，防XSS
        html += webim.Tool.formatText2Html(eleHtml);
        break;
      default:
        webim.Log.error("未知消息元素类型: elemType=" + type);
        break;
    }
  }
  return { html, types };
}

//文字消息
function convertTextMsgToHtml(content) {
  return content.getText();
}

//表情消息
function convertFaceMsgToHtml(content) {
  var faceUrl = null;
  var data = content.getData();
  var index = webim.EmotionDataIndexs[data];

  var emotion = webim.Emotions[index];
  if (emotion && emotion[1]) {
    faceUrl = emotion[1];
  }
  if (faceUrl) {
    return faceUrl;
  } else {
    return data;
  }
}

//自定义数据
function convertCustomMsgToHtml(content) {
  var data = self.$fnc.getImgUrl(content.getData()); //自定义数据
  return data;
}

//发送失败重新发送未做
function showReSend(msg) {
  //resend a dom
  var resendBtn = $('<a href="javascript:;">重发</a>');
  //绑定重发事件
  resendBtn.click(function() {
    //删除当前的dom
    $("#id_" + msg.random).remove();
    //发消息处理
    handleMsgSend(msg.originContent);
  });
  $("#id_" + msg.random)
    .find(".spinner")
    .empty()
    .append(resendBtn);
}

//打开表情包
var showEmotionDialog = function() {
  if (self.emotionFlag) {
    self.emotionFlag = false;
  } else {
    self.emotionFlag = true;
    if (self.emoji.length == 0) {
      for (var index in webim.Emotions) {
        self.emoji.push({
          img: webim.Emotions[index][1],
          text: webim.Emotions[index][0]
        });
      }
    }
  }
};

//发送表情
var selectEmotionImg = function(text) {
  self.emotionFlag = false;
  onSendMsg(text);
};

//上传图片
function uploadPic() {
  var businessType; //业务类型，1-发群图片，2-向好友发图片
  if (selType == webim.SESSION_TYPE.C2C) {
    //向好友发图片
    businessType = webim.UPLOAD_PIC_BUSSINESS_TYPE.C2C_MSG;
  } else if (selType == webim.SESSION_TYPE.GROUP) {
    //发群图片
    businessType = webim.UPLOAD_PIC_BUSSINESS_TYPE.GROUP_MSG;
  }

  uni.chooseImage({
    count: 1, //默认9
    sizeType: ["original", "compressed"], //可以指定是原图还是压缩图，默认二者都有
    sourceType: ["album", "camera"], //从相册选择
    success: res => {
      const tempFilePaths = res.tempFilePaths;
      //console.log(res)

      const uploadTask = uni.uploadFile({
        url: "/api/common/upload/index",
        filePath: tempFilePaths[0],
        name: "file",
        formData: {},
        success: function(res) {
          var result = JSON.parse(res.data);
          sendCustomMsg(result.result);
        }
      });
    }
  });
}

function sendCustomMsg(data) {
  if (!selToID) {
    alert("您还没有好友或群组，暂不能聊天");
    return;
  }

  if (!selSess) {
    selSess = new webim.Session(
      selType,
      selToID,
      selToID,
      friendHeadUrl,
      Math.round(new Date().getTime() / 1000)
    );
  }
  var msg = new webim.Msg(
    selSess,
    true,
    -1,
    -1,
    -1,
    loginInfo.identifier,
    0,
    loginInfo.identifierNick
  );
  var custom_obj = new webim.Msg.Elem.Custom(data, "", "");
  msg.addCustom(custom_obj);
  //调用发送消息接口
  msg.sending = 1;
  webim.sendMsg(
    msg,
    function(resp) {
      addMsg(msg, true);
      bdscrollbar();
    },
    function(err) {
      alert(err.ErrorInfo);
    }
  );
}

//关闭聊天界面
function onClose() {
  //离线
  selToID = null;
  webim.logout();
}

//初始化聊天界面左侧最近会话列表
var initRecentContactList = function(cbOK, cbErr) {
  var options = {
    Count: reqRecentSessCount
  };
  webim.getRecentContactList(
    options,
    function(resp, cbOK) {
      var allSessId = []; //保存第一个会话id
      if (resp.SessionItem && resp.SessionItem.length > 0) {
        //如果存在最近会话记录
        for (var i in resp.SessionItem) {
          allSessId.push(resp.SessionItem[i].To_Account);
        }
        setProfilePortraitClick(allSessId, function() {
          initRecentContactList_info(resp, cbOK);
        });
      }
    },
    cbErr
  );
};

function initRecentContactList_info(resp, cbOK) {
  var tempSess; //临时会话变量
  var firstSessType; //保存第一个会话类型
  var firstSessId; //保存第一个会话id
  recentSessMap = [];
  for (var i in resp.SessionItem) {
    var item = resp.SessionItem[i];
    var type = item.Type; //接口返回的会话类型
    var sessType,
      typeZh,
      sessionId,
      sessionNick = "",
      sessionImage = "",
      senderId = "",
      senderNick = "",
      sessiongender = "";
    if (type == webim.RECENT_CONTACT_TYPE.C2C) {
      //私聊
      typeZh = "私聊";
      sessType = webim.SESSION_TYPE.C2C; //设置会话类型
      sessionId = item.To_Account; //会话id，私聊时为好友ID或者系统账号（值为@TIM#SYSTEM，业务可以自己决定是否需要展示），注意：从To_Account获取,

      if (sessionId == "@TIM#SYSTEM") {
        //先过滤系统消息，，
        webim.Log.warn("过滤好友系统消息,sessionId=" + sessionId);
        continue;
      }
      var key = sessType + "_" + sessionId;
      var c2cInfo = infoMap[key];

      if (c2cInfo && c2cInfo.name) {
        //从infoMap获取c2c昵称
        sessionNick = c2cInfo.name; //会话昵称，私聊时为好友昵称，接口暂不支持返回，需要业务自己获取（前提是用户设置过自己的昵称，通过拉取好友资料接口（支持批量拉取）得到）
      } else {
        //没有找到或者没有设置过
        sessionNick = sessionId; //会话昵称，如果昵称为空，默认将其设成会话id
      }
      if (c2cInfo && c2cInfo.image) {
        //从infoMap获取c2c头像
        sessionImage = c2cInfo.image; //会话头像，私聊时为好友头像，接口暂不支持返回，需要业务自己获取（前提是用户设置过自己的昵称，通过拉取好友资料接口（支持批量拉取）得到）
      } else {
        //没有找到或者没有设置过
        sessionImage = friendHeadUrl; //会话头像，如果为空，默认将其设置demo自带的头像
      }
      if (c2cInfo && c2cInfo.gender == "1") {
        //从infoMap获取c2c头像
        sessiongender = "../../static/img/im/nan.png"; //会话头像，私聊时为好友头像，接口暂不支持返回，需要业务自己获取（前提是用户设置过自己的昵称，通过拉取好友资料接口（支持批量拉取）得到）
      } else if (c2cInfo && c2cInfo.gender == "2") {
        //从infoMap获取c2c头像
        sessiongender = "../../static/img/im/nv.png"; //会话头像，私聊时为好友头像，接口暂不支持返回，需要业务自己获取（前提是用户设置过自己的昵称，通过拉取好友资料接口（支持批量拉取）得到）
      } else {
        //没有找到或者没有设置过
        sessiongender = ""; //会话头像，如果为空，默认将其设置demo自带的头像
      }

      senderId = senderNick = ""; //私聊时，这些字段用不到，直接设置为空
    } else if (type == webim.RECENT_CONTACT_TYPE.GROUP) {
      //群聊
      typeZh = "群聊";
      sessType = webim.SESSION_TYPE.GROUP; //设置会话类型
      sessionId = item.ToAccount; //会话id，群聊时为群ID，注意：从ToAccount获取
      sessionNick = item.GroupNick; //会话昵称，群聊时，为群名称，接口一定会返回

      if (item.GroupImage) {
        //优先考虑接口返回的群头像
        sessionImage = item.GroupImage; //会话头像，群聊时，群头像，如果业务设置过群头像（设置群头像请参考wiki文档-设置群资料接口），接口会返回
      } else {
        //接口没有返回或者没有设置过群头像，再从infoMap获取群头像
        var key = sessType + "_" + sessionId;
        var groupInfo = infoMap[key];
        if (groupInfo && groupInfo.image) {
          //
          sessionImage = groupInfo.image;
        } else {
          //不存在或者没有设置过，则使用默认头像
          sessionImage = groupHeadUrl; //会话头像，如果没有设置过群头像，默认将其设置demo自带的头像
        }
      }
      senderId = item.MsgGroupFrom_Account; //群消息的发送者id

      if (!senderId) {
        //发送者id为空
        webim.Log.warn(
          "群消息发送者id为空,senderId=" + senderId + ",groupid=" + sessionId
        );
        continue;
      }
      if (senderId == "@TIM#SYSTEM") {
        //先过滤群系统消息，因为接口暂时区分不了是进群还是退群等提示消息，
        webim.Log.warn(
          "过滤群系统消息,senderId=" + senderId + ",groupid=" + sessionId
        );
        continue;
      }

      senderNick = item.MsgGroupFromCardName; //优先考虑群成员名片
      if (!senderNick) {
        //如果没有设置群成员名片
        senderNick = item.MsgGroupFromNickName; //再考虑接口是否返回了群成员昵称
        if (!senderNick && !sessionNick) {
          //如果接口没有返回昵称或者没有设置群昵称，从infoMap获取昵称
          var key = webim.SESSION_TYPE.C2C + "_" + senderId;
          var c2cInfo = infoMap[key];
          if (c2cInfo && c2cInfo.name) {
            senderNick = c2cInfo.name; //发送者群昵称
          } else {
            sessionNick = senderId; //如果昵称为空，默认将其设成发送者id
          }
        }
      }
    } else {
      typeZh = "未知类型";
      sessionId = item.ToAccount; //
    }
    if (!sessionId) {
      //会话id为空
      webim.Log.warn("会话id为空,sessionId=" + sessionId);
      continue;
    }

    if (sessionId == "@TLS#NOT_FOUND") {
      //会话id不存在，可能是已经被删除了
      webim.Log.warn("会话id不存在,sessionId=" + sessionId);
      continue;
    }

    if (sessionNick.length > maxNameLen) {
      //帐号或昵称过长，截取一部分，出于demo需要，业务可以自己决定
      sessionNick = sessionNick.substr(0, maxNameLen) + "...";
    }

    tempSess = recentSessMap[sessType + "_" + sessionId];
    if (!tempSess) {
      //先判断是否存在（用于去重），不存在增加一个

      if (!firstSessId) {
        firstSessType = sessType; //记录第一个会话类型
        firstSessId = sessionId; //记录第一个会话id
      }
      recentSessMap[sessType + "_" + sessionId] = {
        SessionType: sessType, //会话类型
        SessionId: sessionId, //会话对象id，好友id或者群id
        SessionNick: sessionNick, //会话昵称，好友昵称或群名称
        SessionImage: sessionImage, //会话头像，好友头像或者群头像
        C2cAccount: senderId, //发送者id，群聊时，才有用
        C2cNick: senderNick, //发送者昵称，群聊时，才有用
        UnreadMsgCount: item.UnreadMsgCount, //未读消息数,私聊时需要通过webim.syncMsgs(initUnreadMsgCount)获取,参考后面的demo，群聊时不需要。
        MsgSeq: item.MsgSeq, //消息seq
        MsgRandom: item.MsgRandom, //消息随机数
        MsgTimeStamp: webim.Tool.formatTimeStamp(item.MsgTimeStamp), //消息时间戳
        MsgGroupReadedSeq: item.MsgGroupReadedSeq || 0,
        MsgShow: item.MsgShow, //消息内容,文本消息为原内容，表情消息为[表情],其他类型消息以此类推
        sessiongender: sessiongender //性别
      };

      //在左侧最近会话列表框中增加一个会话div
      //addSess(sessType, webim.Tool.formatText2Html(sessionId), webim.Tool.formatText2Html(sessionNick), sessionImage, item.UnreadMsgCount, 'sesslist');
    }
  }
  //清空聊天界面
  //document.getElementsByClassName("msgflow")[0].innerHTML = "";

  //tempSess = recentSessMap[firstSessType + "_" + firstSessId]; //选中第一个会话
  //selType = tempSess.SessionType; //初始化当前聊天类型

  //selToID = tempSess.SessionId; //初始化当前聊天对象id

  //selSess = webim.MsgStore.sessByTypeId(selType, selToID); //初始化当前会话对象

  //setSelSessStyleOn(selToID); //设置当前聊天对象选中样式

  if (!self.is_index) {
    for (var i in recentSessMap) {
      //console.log(recentSessMap);
      self.userList.push({
        im: recentSessMap[i].SessionId,
        avatar: recentSessMap[i].SessionImage,
        nickname: recentSessMap[i].SessionNick,
        MsgTimeStamp: recentSessMap[i].MsgTimeStamp,
        MsgShow: recentSessMap[i].MsgShow,
        sex: recentSessMap[i].MsgShow.sessiongender,
        unread: 0,
        search:true,
      });
    }
  }
  webim.syncMsgs(initUnreadMsgCount); //初始化最近会话的消息未读数
  if (cbOK){
    //回调
    cbOK();
  }
}


function initUnreadMsgCount() {
  var sess;
  var sessMap = webim.MsgStore.sessMap();
 
  var arr = new Array;
  for (var i in sessMap) {
    sess = sessMap[i];
    arr[sess.time()]=sess;
  };

  for (var i in arr) {
    sess = arr[i];
    updateSessDiv(
      sess.type(),
      sess.id(),
      sess.name(),
      sess.unread(),
      sess.time(),
      sess.msgs()[sess.unread() - 1].elems[0].content.text
    );
  } 
}

//更新最近会话的未读消息数
function updateSessDiv(
  sess_type,
  to_id,
  name,
  unread_msg_count,
  MsgTimeStamps,
  MsgShow
) {
  
  addSess(
    sess_type,
    to_id,
    name,
    "",
    unread_msg_count,
    "sesslist",
    "",
    MsgTimeStamps,
    MsgShow
  );
}

//新增一条最近会话
function addSess(
  sess_type,
  to_id,
  name,
  face_url,
  unread_msg_count,
  sesslist,
  addPositonType,
  MsgTimeStamps,
  MsgShow
) {
  setProfilePortraitClick([to_id],function(){
    for (var i = 0; i < self.userList.length; i++) {
      if (self.userList[i]["im"] == to_id) {
        self.userList.splice(i, 1);
      }
    }
    var key = sess_type + "_" + to_id;
    var groupInfo = infoMap[key];
    self.userList.unshift({
      im: to_id,
      avatar: groupInfo.image,
      nickname: groupInfo.name,
      username: name,
      MsgTimeStamp: webim.Tool.formatTimeStamp(MsgTimeStamps),
      MsgShow: MsgShow,
      unread: unread_msg_count,
      search:true
    });
  });
  
}

function error(title) {
  uni.showToast({
    title: title,
    duration: 1500,
    mask: false,
    icon: "none"
  });
}

//IE9(含)以下浏览器用到的jsonp回调函数
function jsonpCallback(rspData) {
  webim.setJsonpLastRspData(rspData);
}

//发送文本框按下键盘事件
function onTextareaKeyDown(event) {
  if (event && event.keyCode == 13) {
    onSendMsg();
  }
}

//滚动条
function bdscrollbar(duration = 0, scrollTop = "") {
  let view = document.querySelector('#msg_box');
  self.$nextTick(function() {
    if (scrollTop == "") {
      view.scrollTop = view.scrollHeight - view.clientHeight;
    }
  });
}

export default {
  webimLogin,
  onSendMsg,
  getLastC2CHistoryMsgs,
  getPrePageC2CHistoryMsgs,
  getHistoryMsgCallback,
  showEmotionDialog,
  selectEmotionImg,
  onClose,
  uploadPic,
  bdscrollbar,
  initRecentContactList,
  getLastC2CHistoryMsgs,
  setProfilePortraitClick,
  infoname,
  initUnreadMsgCount,
  sendCustomMsg
};
